home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / pumpkin.zip / PUMPKIN.C < prev    next >
C/C++ Source or Header  |  1991-10-31  |  12KB  |  372 lines
  1. /* Pumpkin.C                                                                */
  2. /* Copyright (c) Genus Microprogramming, Inc. 1988-91  All Rights Reserved. */
  3.  
  4. /****************************************************************************
  5.  
  6.   This program is a C program using the GX Effects and the PCX Programmer's 
  7.   Toolkit to illustrate the use of the Sound Blaster voice support in FX, 
  8.   and how to combine the two.
  9.  
  10.   To Compile: Microsoft C 6.x   cl  /AS pumpkin.c /link gx_cs pcx_cs fx_cs
  11.  
  12.               Quick     C 2.x   QC  pumpkin
  13.                                 (Specify a MAK file, 4 lines: pumpkin.c  )
  14.                                 (                             gx_cs.lib  )
  15.                                 (                             pcx_cs.lib )
  16.                                 (                             fx_cs.lib  )
  17.                                 (press "F5" to run                       )
  18.                            or   QCL /AS pumpkin.c /link gx_cs pcx_cs;
  19.  
  20.               Turbo     C 2.x   tc  pumpkin
  21.                                 (Specify a PRJ file, 4 lines: pumpkin.c  )
  22.                                 (                             gx_cs.lib  )
  23.                                 (                             pcx_cs.lib )
  24.                                 (                             fx_cs.lib  )
  25.                                 (and press "Ctrl-F9" to run              )
  26.                            or   tcc  -I\tc\h -L\tc\lib pumpkin gx_cs.lib pcx_cs.lib fx_cs.lib
  27.  
  28.               Lattice   C 6.x   lc  -ms -L+gx_cs+pcx_cs+fx_cs pumpkin
  29.                                 (Use the Microsoft C small model library )
  30.  
  31.  
  32.          ***** THIS PROGRAM MAY BE FREELY COPIED AND DISTRIBUTED *****
  33.  
  34.  
  35.   Microsoft C version 6.0                 Programmer : Chris Howard 10/31/91
  36.  
  37. *****************************************************************************/
  38.  
  39. #include <stdlib.h>
  40. #include <string.h>
  41. #include <stdio.h>
  42.  
  43. #ifndef LATTICE
  44. #include <conio.h>
  45. #endif
  46.  
  47. /* Include GX Development Series defines */
  48. #include "gxlib.h"
  49. #include "pcxlib.h"
  50. #include "fxlib.h"
  51.  
  52. /* Local defines */
  53. #define  MAXIMAGES   5                 /* Maximum pumpkin images          */
  54. #define  MAXFRAMES   15                /* Maximum frames in pumpkin       */
  55. #define  DELAYBASE   10                /* Delay base between frames       */
  56. #define  X1          150               /* Position of pumpkin frames      */
  57. #define  Y1          250               /*                                 */
  58. #define  X2          400               /*                                 */
  59. #define  Y2          410               /*                                 */
  60.  
  61. /* Globals variables */
  62. int      gxtype    = gxVGA_12;         /* GX Display type                 */
  63. int      memtype   = gxCMM;            /* GX Memory  type                 */
  64. int      libtype   = gxEXE;            /* GX Library type                 */
  65. char     libname[] = "pumpkin.EXE";    /* GX Library name                 */
  66. char     pvoice[]  = "pumpkin.VOC";    /* Pumpkin voice file              */
  67.  
  68. /*       Sentence:    Ha-ppy Ha-lo-we-en       Ha-ah  Ha-ah  Ha-ah  Ha-ah  end */
  69. int      porder[]  = { 1, 2,  1, 1, 3,  2,  1, 4,  1, 4,  1, 4,  1, 4,  1};
  70. int      pdelay[]  = {20,10, 10,20,20,120, 50,40, 20,30, 15,20, 10,20,200};
  71.  
  72. GXLIB    lib;                          /* Library header                  */
  73.  
  74. GXHEADER pumpkin[MAXIMAGES];           /* Pumpkin virtual structures      */
  75.  
  76. FXSOUND  sh;                           /* Sound structures                */
  77.  
  78. char     pcxpal[768];                  /* PCX Palette buffer              */
  79. char     bucket[1024];                 /* GX Library bucket               */
  80. char     buffer[24*1024];              /* GX Kernel buffer                */
  81.  
  82. int      retcode;                      /* General return code             */
  83.  
  84. /**********/
  85.  
  86. /*
  87.  * This function loads all of the images, and the necessary voice files.
  88.  *
  89.  */
  90.  
  91. int  InitSystem(void)
  92. {
  93.   char filename[64];
  94.   long ssize;
  95.   int  imagenum = 0;
  96.   int  i,ok;
  97.  
  98.   /* Assume not successful */
  99.   retcode = !gxSUCCESS;
  100.  
  101.   /* Create sound buffer */
  102.   ssize = fxLibSoundSize(&lib,pvoice,fxVOC);
  103.   retcode = fxCreateSound(&sh,fxVOC,ssize);
  104.   if (retcode == fxSUCCESS) {
  105.  
  106.     /* Load the VOC sound */
  107.     retcode = fxLibSound(&lib,pvoice,&sh);
  108.     if (retcode == fxSUCCESS) {
  109.  
  110.       /* Load the images */
  111.       ok = gxTRUE;
  112.       while (ok && (imagenum < MAXIMAGES)) {
  113.  
  114.         /* Format the image name */
  115.         sprintf(filename,"pumpkin%1d.PCX",imagenum);
  116.  
  117.         /* Load it */
  118.         retcode = pcxLibImage(memtype,&lib,filename,&pumpkin[imagenum],gxtype);
  119.         if (retcode != gxtype) {
  120.  
  121.           /* The image did not load, so free loaded images */
  122.           for (i=imagenum-1; i>=0; i--) {
  123.             retcode = pcxFreeImage(&pumpkin[i]);
  124.           }
  125.  
  126.           /* Set flag */
  127.           ok = !ok;
  128.  
  129.         }
  130.  
  131.         /* Bump */
  132.         imagenum++;
  133.  
  134.       }
  135.  
  136.       /* Were the images successfully loaded? */
  137.       if (ok) {
  138.         /* Yes, so successful */
  139.         retcode = gxSUCCESS;
  140.       }
  141.  
  142.     }
  143.  
  144.   }
  145.  
  146.   /* Return whether successful */
  147.   return(retcode);
  148.   
  149. } /* end of InitSystem */
  150.  
  151. /**********/
  152.  
  153. /*
  154.  * This function cleans up before exiting, removing loaded images and
  155.  * voice files.
  156.  *
  157.  */
  158.  
  159. void ExitSystem(void)
  160. {
  161.   int  i;
  162.  
  163.   /* Free all images */
  164.   for (i=MAXIMAGES-1; i>=0; i--) {
  165.     retcode = pcxFreeImage(&pumpkin[i]);
  166.   }
  167.  
  168.   /* Free the voice file */
  169.   retcode = fxDestroySound(&sh);
  170.  
  171. } /* end of ExitSystem */
  172.  
  173. /**********/
  174.  
  175. /*
  176.  * This function simply displays the exit information screen.
  177.  *
  178.  */
  179.  
  180. void  DisplayInfo(void)
  181. {
  182.  
  183.   printf("╒╡ Pumpkin Info ╞═══════════════════════════════════════════════════════════╕\n");
  184.   printf("│                                                                           │\n");
  185.   printf("│  Pumpkin was written using the power of the Genus GX Development Series.  │\n");
  186.   printf("│                                                                           │\n");
  187.   printf("│  The GX Development Series supports C, Pascal, Basic, Fortran, Clipper    │\n");
  188.   printf("│  and Assembly Language. The products include GX Graphics, GX Effects,     │\n");
  189.   printf("│  GX Text, and the PCX Toolkit. All are written entirely in Assembly       │\n");
  190.   printf("│  and support CGA, HERC, EGA, VGA, and Super VGA modes.                    │\n");
  191.   printf("│                                                                           │\n");
  192.   printf("│  For more information, contact:                                           │\n");
  193.   printf("│                                                                           │\n");
  194.   printf("│                      Genus Microprogramming, Inc.                         │\n");
  195.   printf("│                      2900 Wilcrest, Suite 145                             │\n");
  196.   printf("│                      Houston, TX 77042-3355 USA                           │\n");
  197.   printf("│                                                                           │\n");
  198.   printf("│                      (713) 870-0737  Main                                 │\n");
  199.   printf("│                      (800) 227-0918  Sales/Questions                      │\n");
  200.   printf("│                      (713) 977-0680  Support                              │\n");
  201.   printf("│                      (713) 870-0288  Fax                                  │\n");
  202.   printf("│                      (713) 266-9362  BBS                                  │\n");
  203.   printf("│                      GO GENUS        CompuServe                           │\n");
  204.   printf("│                                                                           │\n");
  205.   printf("╘═══════════════════════════════════════════════════════════════════════════╛\n");
  206.  
  207. } /* end of DisplayInfo */
  208.  
  209. /**********/
  210.  
  211. /*
  212.  * This function actually makes the pumpkin talk.
  213.  *
  214.  */
  215.  
  216. void PumpkinTalk(void)
  217. {
  218.  
  219.   int  f;
  220.  
  221.   /* Set up effect parameters */
  222.   retcode = fxSetEffect(fxRANDOM);
  223.  
  224.   /* Display first image with an effect, before talking */
  225.   retcode = fxVirtualDisplay(&pumpkin[0],0,0,0,0,639,479,fxNONE);
  226.  
  227.   /* Play the pumpkin voice */
  228.   retcode = fxPlaySound(&sh,0,1,fxBACK);
  229.  
  230.   /* Now synchronize the images */
  231.   f=0;
  232.   while ((!kbhit()) && (f < MAXFRAMES)) {
  233.  
  234.     /* Display the image */
  235.     retcode = gxVirtualDisplay(&pumpkin[porder[f]],0,0,X1,Y1,X2,Y2,0);
  236.     retcode = gxDelay(pdelay[f]*DELAYBASE);
  237.  
  238.     /* Bump */
  239.     f++;
  240.  
  241.   }
  242.  
  243.   /* Wait for sound status to be DORMANT */
  244.   while ((!kbhit()) && (fxGetSoundStatus(fxVOC) == fxACTIVE));
  245.  
  246.   /* If key has been pressed, kill any remaining sound */
  247.   if (kbhit()) {
  248.     getch();
  249.     retcode = fxKillSound(fxVOC);
  250.   }
  251.  
  252.   /* Clear the screen */
  253.   retcode = fxClearDisplay(0,0,639,479,gxBLACK,fxNONE);
  254.  
  255. } /* end of PumpkinTalk */
  256.  
  257. /**********/
  258.  
  259. void main(void)
  260. {
  261.  
  262.   /* Display program header */
  263.   printf("\n");
  264.   printf("╒══════════════════════════════════════════════════════════════════════════╕\n");
  265.   printf("│ Pumpkin: A Halloween Program      (MAY BE FREELY COPIED AND DISTRIBUTED) │\n");
  266.   printf("│ Copyright (c) Genus Microprogramming, Inc. 1988-91  All Rights Reserved. │\n");
  267.   printf("╘══════════════════════════════════════════════════════════════════════════╛\n");
  268.   printf("\n");
  269.  
  270.   /* Get a key, to begin */
  271.   printf("Press a key to run . . .");
  272.   getch();
  273.   printf("\n");
  274.  
  275.   /* Make sure we can display the image with current hardware (need EGA) */
  276.   if (gxVerifyDisplayType(gxtype) == gxSUCCESS) {
  277.  
  278.     /* See if SoundBlaster is installed */
  279.     if (fxSBInstalled() == fxSUCCESS) { 
  280.     
  281.       /* Check for SoundBlaster */
  282.       retcode = fxInstallSound(fxSOUNDBLASTER);
  283.       if (retcode == fxSUCCESS) {
  284.  
  285.         /* Open the lib */
  286.         retcode = gxOpenLib(libtype,libname,&lib,bucket,1024);
  287.         if (retcode == gxSUCCESS) {
  288.  
  289.           /* Load the images and sound files */
  290.           retcode = InitSystem();
  291.           if (retcode == gxSUCCESS) {
  292.  
  293.             /* Set the display type and mode */
  294.             retcode = gxSetDisplay(gxtype);
  295.             retcode = gxSetMode(gxGRAPHICS);
  296.             if (retcode == gxSUCCESS) {
  297.             
  298.               /* Get the file palette */
  299.               retcode = pcxGetLibPalette(gxtype,&lib,"pumpkin1.pcx",pcxpal);
  300.               if (retcode == pcxSUCCESS) {
  301.  
  302.                 /* Set the display palette */
  303.                 retcode = gxSetDisplayPalette(pcxpal);
  304.                 if (retcode == gxSUCCESS) {
  305.  
  306.                   /* Now make the pumpkin talk */
  307.                   PumpkinTalk();
  308.  
  309.                 }
  310.                 else {
  311.                   /* Error setting the palette on the display */
  312.                   printf("gxSetDisplayPalette error: %d\n",retcode);
  313.                   getch();
  314.                 }
  315.             
  316.               }
  317.               else {
  318.                 /* Error getting the palette from the file */
  319.                 printf("pcxGetLibPalette error: %d\n",retcode);
  320.                 getch();
  321.               }
  322.  
  323.               /* Return to text mode */
  324.               retcode = gxSetMode(gxTEXT);
  325.  
  326.             }
  327.             else {
  328.               /* Error setting the mode */
  329.               printf("gxSetMode error: %d\n",retcode);
  330.             }
  331.  
  332.             /* Clean up */
  333.             ExitSystem();
  334.  
  335.             /* Display info screen */
  336.             DisplayInfo();
  337.  
  338.           }
  339.  
  340.           /* Close the lib */
  341.           retcode = gxCloseLib(&lib);
  342.  
  343.         }
  344.         else {
  345.           /* Error opening lib */
  346.           printf("gxOpenLib error: %d\n",retcode);
  347.         }
  348.  
  349.         /* Remove the SoundBlaster driver */
  350.         retcode = fxRemoveSound(fxSOUNDBLASTER);
  351.  
  352.       }
  353.       else {
  354.         /* Error installing SoundBlaster driver */
  355.         printf("fxInstallSound error: %d\n",retcode);
  356.       }
  357.  
  358.     }
  359.     else {
  360.       /* Necessary hardware is not available to run this program */
  361.       printf("Error: This program requires a SoundBlaster card to run . . .");
  362.     }
  363.  
  364.   }
  365.   else {
  366.     /* Necessary hardware is not available to run this program */
  367.     printf("Error: This program requires at least a VGA system to run . . .");
  368.   }
  369.  
  370. } /* end of main */
  371.  
  372.